// ThrottledOutputStream - output stream with throttling
//
// Copyright (C)1996,1998 by Jef Poskanzer <jef@acme.com>. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
// SUCH DAMAGE.
//
// Visit the ACME Labs Java page for up-to-date versions of this and other
// fine Java utilities: http://www.acme.com/java/

package Acme.Serve;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/// Output stream with throttling.
// <P>
// Restricts output to a specified rate.  Also includes a static utility
// routine for parsing a file of throttle settings.
// <P>
// <A HREF="/resources/classes/Acme/Serve/ThrottledOutputStream.java">Fetch the software.</A><BR>
// <A HREF="/resources/classes/Acme.tar.Z">Fetch the entire Acme package.</A>

/**
 * @deprecated See resteasy-undertow module.
 */
@Deprecated
public class ThrottledOutputStream extends FilterOutputStream
{

   // / Parses a standard throttle file.
   // <P>
   // A throttle file lets you set maximum byte rates on filename patterns.
   // The format of the throttle file is very simple. A # starts a
   // comment, and the rest of the line is ignored. Blank lines are ignored.
   // The rest of the lines should consist of a pattern, whitespace, and a
   // number. The pattern is a simple shell-style filename pattern, using
   // ? and *, or multiple such patterns separated by |.
   // <P>
   // The numbers in the file are byte rates, specified in units of bytes
   // per second. For comparison, a v.32b/v.42b modem gives about
   // 1500/2000 B/s depending on compression, a double-B-channel ISDN line
   // about 12800 B/s, and a T1 line is about 150000 B/s.
   // <P>
   // Example:
   // <BLOCKQUOTE><PRE>
   // # throttle file for www.acme.com
   // * 100000 # limit total web usage to 2/3 of our T1
   // *.jpg|*.gif 50000 # limit images to 1/3 of our T1
   // *.mpg 20000 # and movies to even less
   // jef/* 20000 # jef's pages are too popular
   // </PRE></BLOCKQUOTE>
   // <P>
   // The routine returns a WildcardDictionary. Do a lookup in this
   // dictionary using a filename, and you'll get back a ThrottleItem
   // containing the corresponding byte rate.
   public static Acme.WildcardDictionary parseThrottleFile(String filename) throws IOException
   {
      Acme.WildcardDictionary wcd = new Acme.WildcardDictionary();
      File thFile = new File(filename);
      if (thFile.isAbsolute() == false)
         thFile = new File(System.getProperty("user.dir", "."), thFile.getName());
      BufferedReader br = new BufferedReader(new FileReader(thFile));
      while (true)
      {
         String line = br.readLine();
         if (line == null)
            break;
         int i = line.indexOf('#');
         if (i != -1)
            line = line.substring(0, i);
         line = line.trim();
         if (line.length() == 0)
            continue;
         String[] words = Acme.Utils.splitStr(line);
         if (words.length != 2)
            throw new IOException("malformed throttle line: " + line);
         try
         {
            wcd.put(words[0], new ThrottleItem(Long.parseLong(words[1])));
         }
         catch (NumberFormatException e)
         {
            throw new IOException("malformed number in throttle line: " + line);
         }
      }
      br.close();
      return wcd;
   }

   private long maxBps;

   private long bytes;

   private long start;

   // / Constructor.
   public ThrottledOutputStream(OutputStream out, long maxBps)
   {
      super(out);
      this.maxBps = maxBps;
      bytes = 0;
      start = System.currentTimeMillis();
   }

   private byte[] oneByte = new byte[1];

   // / Writes a byte. This method will block until the byte is actually
   // written.
   // @param b the byte to be written
   // @exception IOException if an I/O error has occurred
   public void write(int b) throws IOException
   {
      oneByte[0] = (byte) b;
      write(oneByte, 0, 1);
   }

   // / Writes a subarray of bytes.
   // @param b the data to be written
   // @param off the start offset in the data
   // @param len the number of bytes that are written
   // @exception IOException if an I/O error has occurred
   public void write(byte b[], int off, int len) throws IOException
   {
      // Check the throttle.
      bytes += len;
      long elapsed = Math.max(System.currentTimeMillis() - start, 1);

      long bps = bytes * 1000L / elapsed;
      if (bps > maxBps)
      {
         // Oops, sending too fast.
         long wakeElapsed = bytes * 1000L / maxBps;
         try
         {
            Thread.sleep(wakeElapsed - elapsed);
         }
         catch (InterruptedException ignore)
         {
         }
      }

      // Write the bytes.
      out.write(b, off, len);
   }

}
